编程范式游记（3）- 类型系统和泛型的本质 [2026重制版]

// JavaScript 2018: 运行时才能发现问题
function processItems(items) {
    let total = 0;
    for (let item of items) {
        // 如果item不是数字？运行时报错或产生NaN
        total += item.price * item.quantity;
    }
    return total;
}
 
// 调用时传入错误类型，直到运行才发现
processItems([
    { name: "商品A", price: "100", quantity: 2 }, // price是字符串！
    { name: "商品B", price: 200, quantity: "三" }  // quantity是中文！
]);
// 结果：total = "100200NaNNaN"  😱

// 定义精确的接口约束
interface OrderItem {
    name: string;
    price: number;
    quantity: number;
}
 
interface Order {
    items: OrderItem[];
    customer?: CustomerInfo;  // 可选属性
    status: 'pending' | 'processing' | 'shipped' | 'delivered';
}
 
type OrderStatus = Order['status']; // 提取类型
 
// 泛型函数 + 条件类型
function calculateTotal<T extends { price: number; quantity: number }>(
    items: T[]
): number {
    return items.reduce(
        (sum, item) => sum + item.price * item.quantity,
        0
    );
}
 
// 使用映射类型创建只读版本
type ReadonlyOrder = Readonly<Order>;
 
// 使用实用工具类型
type RequiredOrder = Required<Pick<Order, 'customer'>>;
 
const order: Order = {
    items: [
        { name: "笔记本电脑", price: 8000, quantity: 2 },
        { name: "机械键盘", price: 500, quantity: 5 },
    ],
    status: 'pending'
};
 
// ✅ 编译期就能捕获错误！
const total = calculateTotal(order.items); // 类型推导为number
console.log(`订单总额: ¥${total.toLocaleString()}`);

from __future__ import annotations
from dataclasses import dataclass
from typing import Generic, TypeVar, Protocol
 
# PEP 695: 类级别的类型参数
@dataclass
class OrderItem[G: (int, float)]:
    """支持int或float的泛型价格"""
    name: str
    price: G
    quantity: int
 
 
# 协议（Protocol）定义行为约束
class SupportsTotal(Protocol):
    def get_total(self) -> float: ...
 
 
def process_order[T: SupportsTotal](order: T) -> dict[str, float]:
    """
    处理订单并返回统计信息
    使用新的类型参数语法（PEP 695）
    """
    total = order.get_total()
    tax = total * 0.13  # 13%税率
    grand_total = total + tax
 
    return {
        "subtotal": round(total, 2),
        "tax": round(tax, 2),
        "grand_total": round(grand_total, 2),
    }
 
 
@dataclass
class OnlineOrder:
    items: list[OrderItem[float]]
 
    def get_total(self) -> float:
        return sum(item.price * item.quantity for item in self.items)
 
 
# 使用示例
order = OnlineOrder(
    items=[
        OrderItem("笔记本电脑", 8000.00, 2),
        OrderItem("机械键盘", 500.00, 5),
    ]
)
 
result = process_order(order)
print(f"订单明细: {result}")
# mypy/pyright会在编译期检查类型一致性

use std::collections::HashMap;
 
#[derive(Debug, Clone)]
struct OrderItem {
    name: String,
    price: f64,
    quantity: u32,
}
 
struct Order<'a> {
    items: Vec<OrderItem>,
    customer: &'a CustomerInfo,  // 生命周期标注
    status: OrderStatus,
}
 
#[derive(Debug)]
enum OrderStatus {
    Pending,
    Processing,
    Shipped,
    Delivered,
}
 
struct CustomerInfo {
    id: u32,
    name: String,
    level: CustomerLevel,
}
 
enum CustomerLevel {
    Regular,
    VIP,
    Enterprise,
}
 
impl Order<'_> {
    fn calculate_total(&self) -> f64 {
        self.items
            .iter()
            .map(|item| item.price * item.quantity as f64)
            .sum()
    }
 
    fn apply_discount(&self) -> f64 {
        let total = self.calculate_total();
        match self.customer.level {
            CustomerLevel::Regular => total,
            CustomerLevel::VIP => total * 0.95,   // 95折
            CustomerLevel::Enterprise => total * 0.85, // 85折
        }
    }
}
 
fn main() {
    let customer = CustomerInfo {
        id: 1001,
        name: String::from("张三"),
        level: CustomerLevel::VIP,
    };
 
    let order = Order {
        items: vec![
            OrderItem { name: String::from("笔记本"), price: 8000.0, quantity: 2 },
            OrderItem { name: String::from("键盘"), price: 500.0, quantity: 5 },
        ],
        customer: &customer,
        status: OrderStatus::Pending,
    };
 
    println!("原价: ¥{:.2}", order.calculate_total());
    println!("VIP价: ¥{:.2}", order.apply_discount());
}

// Java 8: 冗长的类型声明
Map<String, List<OrderItem>> orderMap = new HashMap<String, List<OrderItem>>();
List<OrderItem> items = orderMap.getOrDefault("order_001", new ArrayList<OrderItem>());
 
for (OrderItem item : items) {
    System.out.println(item.getName() + ": " + item.getPrice());
}

package main
 
import "fmt"
 
// 泛型函数：自动推断返回类型
func Sum[T ~int | ~float64](numbers ...T) T {
	var total T
	for _, n := range numbers {
		total += n
	}
	return total
}
 
// 约束接口：定义类型的行为
type Stringer interface {
	String() string
}
 
// 泛型结构体
type Container[T any] struct {
	items []T
}
 
func (c *Container[T]) Add(item T) {
	c.items = append(c.items, item)
}
 
func (c *Container[T]) GetAll() []T {
	return c.items
}
 
func main() {
	// 自动推断T为int
	intSum := Sum(1, 2, 3, 4, 5)
	fmt.Printf("整数求和: %d\n", intSum)
 
	// 自动推断T为float64
	floatSum := Sum(1.1, 2.2, 3.3)
	fmt.Printf("浮点求和: %.2f\n", floatSum)
 
	// 泛型容器使用
	strContainer := &Container[string]{}
	strContainer.Add("Hello")
	strContainer.Add("World")
	fmt.Println(strContainer.GetAll())
}

// TypeScript 5.x 的控制流类型收窄
function processValue(value: string | number | null) {
    if (value === null) {
        console.log("值为null");
        return;
    }
 
    // 此处value类型已收窄为 string | number
    if (typeof value === "string") {
        // 此处value类型为string
        console.log(value.toUpperCase());
    } else {
        // 此处value类型为number
        console.log((value * 2).toFixed(2));
    }
}
 
// 模板字面量类型
type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';
type APIRoute = `/api/${string}`;
 
function fetchAPI(
    method: HTTPMethod,
    url: APIRoute,
    body?: unknown
): Promise<Response> {
    return fetch(url, { method, body });
}
 
// 类型守卫
function isOrder(item: unknown): item is Order {
    return (
        typeof item === 'object' &&
        item !== null &&
        'items' in item &&
        Array.isArray((item as Order).items)
    );
}
 
// 使用
const data: unknown = fetchDataFromAPI();
if (isOrder(data)) {
    // data在此处被推断为Order类型
    const total = data.items.reduce((sum, item) =>
        sum + item.price * item.quantity, 0
    );
}

// ❌ 过于宽泛
function processData(data: any): any { ... }
 
// ✅ 明确类型
interface UserData {
    id: string;
    name: string;
    email: string;
    createdAt: Date;
}
 
function processData(data: UserData): ProcessedResult { ... }

from typing import Literal, Union
 
# Python 3.10+ 联合类型语法
def set_status(
    order_id: str,
    status: Literal['pending', 'processing', 'shipped', 'cancelled']
) -> None:
    """状态只能是预定义的字面量之一"""
    ...
 
# 替代注释式的字符串
# def set_status(order_id, status): # status: 'pending'|'processing'...

// TypeScript: 防止将UserId误传给OrderId
type UserId = string & { readonly brand: unique symbol };
type OrderId = string & { readonly brand: unique symbol };
 
function createUserId(id: string): UserId {
    return id as UserId;
}
 
function createOrderId(id: string): OrderId {
    return id as OrderId;
}
 
function getUser(id: UserId): User { ... }
function getOrder(id: OrderId): Order { ... }
 
const userId = createUserId('user_123');
const orderId = createOrderId('order_456');
 
getUser(userId);     // ✅ 正确
getUser(orderId);    // ❌ 编译错误! Type 'OrderId' is not assignable to 'UserId'

// Rust: trait bounds作为文档和约束
use std::fmt::Display;
use std::error::Error;
 
/// 对可显示的项目列表进行格式化输出
///
/// # Type Bounds
/// - `T: Display` - 必须能格式化为字符串
/// - `I: IntoIterator<Item = T>` - 必须可迭代
fn format_items<T, I>(items: I) -> String
where
    T: Display,
    I: IntoIterator<Item = T>,
{
    items
        .into_iter()
        .map(|item| format!("- {}", item))
        .collect::<Vec<_>>()
        .join("\n")
}

# Python 3.11+: 使用Union代替异常进行流程控制
from dataclasses import dataclass
from typing import Union
 
@dataclass
class Success[T]:
    value: T
 
@dataclass
class Error:
    message: str
    code: int
 
Result = Union[Success[T], Error]
 
def divide(a: float, b: float) -> Result[float]:
    if b == 0:
        return Error(message="除数不能为零", code=400)
    return Success(value=a / b)
 
# 使用模式匹配处理结果 (Python 3.10+ match语句)
result = divide(10.0, 3.0)
match result:
    case Success(value=value):
        print(f"结果: {value:.2f}")
    case Error(message=msg, code=code):
        print(f"错误 [{code}]: {msg}")

// TypeScript: 使用 @ts-expect-error 进行类型单元测试
import { expectType } from 'ts-expect';
 
function add<T extends number>(a: T, b: T): T {
    return (a + b) as T;
}
 
// 测试类型推断是否正确
const result = add(1, 2);
expectType<number>(result); // ✅ 通过
 
// 测试错误类型是否能被检测到
// @ts-expect-error - Argument of type 'string' is not assignable to parameter
add("hello", "world");